< Summary

Class:GDX.Tables.StableTable
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs
Covered lines:0
Uncovered lines:786
Coverable lines:786
Total lines:1260
Line coverage:0% (0 of 786)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:135
Method coverage:0% (0 of 135)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableTable()0%2100%
GetDataVersion()0%2100%
GetColumnCount()0%2100%
GetRowCount()0%2100%
GetOrderedColumns()0%42600%
AddRow(...)0%30500%
AddRows(...)0%90900%
RemoveRow(...)0%6200%
RemoveRows(...)0%6200%
AddColumn(...)0%9923100%
RemoveColumn(...)0%9303000%
SetString(...)0%2100%
SetBool(...)0%2100%
SetChar(...)0%2100%
SetSByte(...)0%2100%
SetByte(...)0%2100%
SetShort(...)0%2100%
SetUShort(...)0%2100%
SetInt(...)0%2100%
SetUInt(...)0%2100%
SetLong(...)0%2100%
SetULong(...)0%2100%
SetFloat(...)0%2100%
SetDouble(...)0%2100%
SetVector2(...)0%2100%
SetVector3(...)0%2100%
SetVector4(...)0%2100%
SetVector2Int(...)0%2100%
SetVector3Int(...)0%2100%
SetQuaternion(...)0%2100%
SetRect(...)0%2100%
SetRectInt(...)0%2100%
SetColor(...)0%2100%
SetLayerMask(...)0%2100%
SetBounds(...)0%2100%
SetBoundsInt(...)0%2100%
SetHash128(...)0%2100%
SetGradient(...)0%2100%
SetAnimationCurve(...)0%2100%
SetObject(...)0%2100%
GetString(...)0%2100%
GetBool(...)0%2100%
GetChar(...)0%2100%
GetSByte(...)0%2100%
GetByte(...)0%2100%
GetShort(...)0%2100%
GetUShort(...)0%2100%
GetInt(...)0%2100%
GetUInt(...)0%2100%
GetLong(...)0%2100%
GetULong(...)0%2100%
GetFloat(...)0%2100%
GetDouble(...)0%2100%
GetVector2(...)0%2100%
GetVector3(...)0%2100%
GetVector4(...)0%2100%
GetVector2Int(...)0%2100%
GetVector3Int(...)0%2100%
GetQuaternion(...)0%2100%
GetRect(...)0%2100%
GetRectInt(...)0%2100%
GetColor(...)0%2100%
GetLayerMask(...)0%2100%
GetBounds(...)0%2100%
GetBoundsInt(...)0%2100%
GetHash128(...)0%2100%
GetGradient(...)0%2100%
GetAnimationCurve(...)0%2100%
GetObject(...)0%2100%
GetStringRef(...)0%2100%
GetBoolRef(...)0%2100%
GetCharRef(...)0%2100%
GetSbyteRef(...)0%2100%
GetByteRef(...)0%2100%
GetShortRef(...)0%2100%
GetUshortRef(...)0%2100%
GetIntRef(...)0%2100%
GetUintRef(...)0%2100%
GetLongRef(...)0%2100%
GetUlongRef(...)0%2100%
GetFloatRef(...)0%2100%
GetDoubleRef(...)0%2100%
GetVector2Ref(...)0%2100%
GetVector3Ref(...)0%2100%
GetVector4Ref(...)0%2100%
GetVector2IntRef(...)0%2100%
GetVector3IntRef(...)0%2100%
GetQuaternionRef(...)0%2100%
GetRectRef(...)0%2100%
GetRectIntRef(...)0%2100%
GetColorRef(...)0%2100%
GetLayerMaskRef(...)0%2100%
GetBoundsRef(...)0%2100%
GetBoundsIntRef(...)0%2100%
GetHash128Ref(...)0%2100%
GetGradientRef(...)0%2100%
GetAnimationCurveRef(...)0%2100%
GetObjectRef(...)0%2100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
AddColumnInternal[T](...)0%5062200%
RemoveColumnInternal[T](...)0%20400%
InsertRowsOfTypeInternal[T](...)0%42600%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%2100%
GetCell[T](...)0%2100%
SetCell[T](...)0%2100%
GetColumn[T](...)0%2100%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2023 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8
 9namespace GDX.Tables
 10{
 11
 12    [CreateAssetMenu(menuName = "GDX/Stable Table", fileName = "GDXStableTable")]
 13    [Serializable]
 14    public class StableTable : ScriptableObject, ITable
 15    {
 16        [Serializable]
 17        internal struct ColumnEntry
 18        {
 19            public Serializable.SerializableTypes ColumnType;
 20            public int columnDenseIndex;
 21        }
 22
 23        [SerializeField] internal ArrayHolder<string>[] allStringColumns;
 24        [SerializeField] internal ArrayHolder<bool>[] allBoolColumns;
 25        [SerializeField] internal ArrayHolder<char>[] allCharColumns;
 26        [SerializeField] internal ArrayHolder<sbyte>[] allSbyteColumns;
 27        [SerializeField] internal ArrayHolder<byte>[] allByteColumns;
 28        [SerializeField] internal ArrayHolder<short>[] allShortColumns;
 29        [SerializeField] internal ArrayHolder<ushort>[] allUshortColumns;
 30        [SerializeField] internal ArrayHolder<int>[] allIntColumns;
 31        [SerializeField] internal ArrayHolder<uint>[] allUintColumns;
 32        [SerializeField] internal ArrayHolder<long>[] allLongColumns;
 33        [SerializeField] internal ArrayHolder<ulong>[] allUlongColumns;
 34        [SerializeField] internal ArrayHolder<float>[] allFloatColumns;
 35        [SerializeField] internal ArrayHolder<double>[] allDoubleColumns;
 36        [SerializeField] internal ArrayHolder<Vector2>[] allVector2Columns;
 37        [SerializeField] internal ArrayHolder<Vector3>[] allVector3Columns;
 38        [SerializeField] internal ArrayHolder<Vector4>[] allVector4Columns;
 39        [SerializeField] internal ArrayHolder<Vector2Int>[] allVector2IntColumns;
 40        [SerializeField] internal ArrayHolder<Vector3Int>[] allVector3IntColumns;
 41        [SerializeField] internal ArrayHolder<Quaternion>[] allQuaternionColumns;
 42        [SerializeField] internal ArrayHolder<Rect>[] allRectColumns;
 43        [SerializeField] internal ArrayHolder<RectInt>[] allRectIntColumns;
 44        [SerializeField] internal ArrayHolder<Color>[] allColorColumns;
 45        [SerializeField] internal ArrayHolder<LayerMask>[] allLayerMaskColumns;
 46        [SerializeField] internal ArrayHolder<Bounds>[] allBoundsColumns;
 47        [SerializeField] internal ArrayHolder<BoundsInt>[] allBoundsIntColumns;
 48        [SerializeField] internal ArrayHolder<Hash128>[] allHash128Columns;
 49        [SerializeField] internal ArrayHolder<Gradient>[] allGradientColumns;
 50        [SerializeField] internal ArrayHolder<AnimationCurve>[] allAnimationCurveColumns;
 51        [SerializeField] internal ArrayHolder<UnityEngine.Object>[] allObjectRefColumns;
 052        [SerializeField] internal ArrayHolder<string>[] allColumnNames = new ArrayHolder<string>[Serializable.Serializab
 053        [SerializeField] internal ArrayHolder<int>[] allColumnOrders = new ArrayHolder<int>[Serializable.SerializableTyp
 54
 55
 56        [SerializeField]
 57        internal string[] allRowNames;
 58
 59        [SerializeField]
 60        internal int rowCount;
 61
 62        [SerializeField]
 63        internal ColumnEntry[] columnIDToDenseIndexMap;
 64
 65        // TODO move with other block
 066        [SerializeField] ArrayHolder<int>[] columnDenseIndexToIDMap = new ArrayHolder<int>[Serializable.SerializableType
 67
 68        [SerializeField]
 69        internal int columnEntriesFreeListHead;
 70
 71        [SerializeField]
 72        internal int combinedColumnCount;
 73
 74        [SerializeField]
 075        internal ulong dataVersion = 1;
 76
 77
 78        public ulong GetDataVersion()
 079        {
 080            return dataVersion;
 081        }
 82
 83        /// <inheritdoc />
 84        public int GetColumnCount()
 085        {
 086            return combinedColumnCount;
 087        }
 88
 89        /// <inheritdoc />
 90        public int GetRowCount()
 091        {
 092            return rowCount;
 093        }
 94
 95        public ITable.ColumnDescription[] GetOrderedColumns()
 096        {
 097            if (combinedColumnCount == 0) return null;
 098            ITable.ColumnDescription[] returnArray = new ITable.ColumnDescription[combinedColumnCount];
 99
 0100            for (int columnIndex = 0; columnIndex < Serializable.SerializableTypesCount; columnIndex++)
 0101            {
 102
 0103                int[] columnOrders = allColumnOrders[columnIndex].TArray;
 0104                int columnOrdersLength = columnOrders?.Length ?? 0;
 105
 0106                int[] columnIndices = columnDenseIndexToIDMap[columnIndex].TArray;
 0107                string[] columnNames = allColumnNames[columnIndex].TArray;
 108
 0109                for (int i = 0; i < columnOrdersLength; i++)
 0110                {
 0111                    returnArray[columnOrders[i]] = new ITable.ColumnDescription
 112                    {
 113                        Name =  columnNames[i],
 114                        Index = columnIndices[i],
 115                        Type = (Serializable.SerializableTypes)columnIndex
 116                    };
 0117                }
 0118            }
 0119            return returnArray;
 0120        }
 121
 122
 123        // END - View Hacks
 124
 125        // TODO: Way to set column name
 126
 127
 128
 129        public void AddRow(string rowName = null, int insertAt = -1)
 0130        {
 0131            insertAt = insertAt < 0 ? rowCount : insertAt;
 132
 0133            Array.Resize(ref allRowNames, rowCount + 1);
 0134            for (int i = rowCount; i > insertAt; i--)
 0135            {
 0136                allRowNames[i] = allRowNames[i - 1];
 0137            }
 138
 0139            rowName ??= string.Empty;
 0140            allRowNames[insertAt] = rowName;
 141
 0142            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, 1);
 0143            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, 1);
 0144            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, 1);
 0145            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, 1);
 0146            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, 1);
 0147            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, 1);
 0148            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, 1);
 0149            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, 1);
 0150            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, 1);
 0151            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, 1);
 0152            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, 1);
 0153            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, 1);
 0154            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, 1);
 0155            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, 1);
 0156            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, 1);
 0157            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, 1);
 0158            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, 1);
 0159            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, 1);
 0160            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, 1);
 0161            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, 1);
 0162            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, 1);
 0163            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, 1);
 0164            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, 1);
 0165            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, 1);
 0166            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, 1);
 0167            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, 1);
 0168            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, 1);
 0169            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, 1);
 0170            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, 1);
 171
 0172            ++rowCount;
 0173            dataVersion++;
 0174        }
 175
 176        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAt = -1)
 0177        {
 0178            insertAt = insertAt < 0 ? rowCount : insertAt;
 179
 0180            Array.Resize(ref allRowNames, rowCount + 1);
 0181            for (int i = rowCount; i > insertAt; i--)
 0182            {
 0183                allRowNames[i] = allRowNames[i - 1];
 0184            }
 185
 0186            string empty = string.Empty;
 0187            int rowNamesLength = rowNames?.Length ?? 0;
 0188            for (int i = 0; i < rowNames.Length; i++)
 0189            {
 0190                string nameAt = rowNames[i];
 0191                allRowNames[insertAt + i] = nameAt ?? empty;
 0192            }
 193
 0194            for (int i = rowNamesLength; i < numberOfNewRows; i++)
 0195            {
 0196                allRowNames[insertAt + i] = empty;
 0197            }
 198
 0199            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, numberOfNewRows);
 0200            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, numberOfNewRows);
 0201            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, numberOfNewRows);
 0202            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, numberOfNewRows);
 0203            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, numberOfNewRows);
 0204            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, numberOfNewRows);
 0205            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, numberOfNewRows);
 0206            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, numberOfNewRows);
 0207            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, numberOfNewRows);
 0208            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, numberOfNewRows);
 0209            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, numberOfNewRows);
 0210            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, numberOfNewRows);
 0211            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, numberOfNewRows);
 0212            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, numberOfNewRows);
 0213            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, numberOfNewRows);
 0214            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, numberOfNewRows);
 0215            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, numberOfNewRows);
 0216            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, numberOfNewRows);
 0217            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, numberOfNewRows);
 0218            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, numberOfNewRows);
 0219            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, numberOfNewRows);
 0220            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, numberOfNewRows);
 0221            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, numberOfNewRows);
 0222            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, numberOfNewRows);
 0223            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, numberOfNewRows);
 0224            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, numberOfNewRows);
 0225            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, numberOfNewRows);
 0226            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, numberOfNewRows);
 0227            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, numberOfNewRows);
 228
 0229            rowCount += numberOfNewRows;
 0230            dataVersion++;
 0231        }
 232
 233        public void RemoveRow(int removeAt)
 0234        {
 0235            int newRowCount = rowCount - 1;
 0236            for (int j = removeAt; j < newRowCount; j++)
 0237            {
 0238                allRowNames[j] = allRowNames[j + 1];
 0239            }
 240
 0241            Array.Resize(ref allRowNames, newRowCount);
 242
 0243            DeleteRowsOfTypeInternal(ref allStringColumns, removeAt, 1);
 0244            DeleteRowsOfTypeInternal(ref allBoolColumns, removeAt, 1);
 0245            DeleteRowsOfTypeInternal(ref allCharColumns, removeAt, 1);
 0246            DeleteRowsOfTypeInternal(ref allSbyteColumns, removeAt, 1);
 0247            DeleteRowsOfTypeInternal(ref allByteColumns, removeAt, 1);
 0248            DeleteRowsOfTypeInternal(ref allShortColumns, removeAt, 1);
 0249            DeleteRowsOfTypeInternal(ref allUshortColumns, removeAt, 1);
 0250            DeleteRowsOfTypeInternal(ref allIntColumns, removeAt, 1);
 0251            DeleteRowsOfTypeInternal(ref allUintColumns, removeAt, 1);
 0252            DeleteRowsOfTypeInternal(ref allLongColumns, removeAt, 1);
 0253            DeleteRowsOfTypeInternal(ref allUlongColumns, removeAt, 1);
 0254            DeleteRowsOfTypeInternal(ref allFloatColumns, removeAt, 1);
 0255            DeleteRowsOfTypeInternal(ref allDoubleColumns, removeAt, 1);
 0256            DeleteRowsOfTypeInternal(ref allVector2Columns, removeAt, 1);
 0257            DeleteRowsOfTypeInternal(ref allVector3Columns, removeAt, 1);
 0258            DeleteRowsOfTypeInternal(ref allVector4Columns, removeAt, 1);
 0259            DeleteRowsOfTypeInternal(ref allVector2IntColumns, removeAt, 1);
 0260            DeleteRowsOfTypeInternal(ref allVector3IntColumns, removeAt, 1);
 0261            DeleteRowsOfTypeInternal(ref allQuaternionColumns, removeAt, 1);
 0262            DeleteRowsOfTypeInternal(ref allRectColumns, removeAt, 1);
 0263            DeleteRowsOfTypeInternal(ref allRectIntColumns, removeAt, 1);
 0264            DeleteRowsOfTypeInternal(ref allColorColumns, removeAt, 1);
 0265            DeleteRowsOfTypeInternal(ref allLayerMaskColumns, removeAt, 1);
 0266            DeleteRowsOfTypeInternal(ref allBoundsColumns, removeAt, 1);
 0267            DeleteRowsOfTypeInternal(ref allBoundsIntColumns, removeAt, 1);
 0268            DeleteRowsOfTypeInternal(ref allHash128Columns, removeAt, 1);
 0269            DeleteRowsOfTypeInternal(ref allGradientColumns, removeAt, 1);
 0270            DeleteRowsOfTypeInternal(ref allAnimationCurveColumns, removeAt, 1);
 0271            DeleteRowsOfTypeInternal(ref allObjectRefColumns, removeAt, 1);
 272
 0273            --rowCount;
 0274            dataVersion++;
 0275        }
 276
 277        public void RemoveRows(int removeAt, int numberOfRowsToDelete)
 0278        {
 0279            int newRowCount = rowCount - numberOfRowsToDelete;
 0280            for (int j = removeAt; j < rowCount - numberOfRowsToDelete; j++)
 0281            {
 0282                allRowNames[j] = allRowNames[j + numberOfRowsToDelete];
 0283            }
 284
 0285            Array.Resize(ref allRowNames, newRowCount);
 286
 0287            DeleteRowsOfTypeInternal(ref allStringColumns, removeAt, numberOfRowsToDelete);
 0288            DeleteRowsOfTypeInternal(ref allBoolColumns, removeAt, numberOfRowsToDelete);
 0289            DeleteRowsOfTypeInternal(ref allCharColumns, removeAt, numberOfRowsToDelete);
 0290            DeleteRowsOfTypeInternal(ref allSbyteColumns, removeAt, numberOfRowsToDelete);
 0291            DeleteRowsOfTypeInternal(ref allByteColumns, removeAt, numberOfRowsToDelete);
 0292            DeleteRowsOfTypeInternal(ref allShortColumns, removeAt, numberOfRowsToDelete);
 0293            DeleteRowsOfTypeInternal(ref allUshortColumns, removeAt, numberOfRowsToDelete);
 0294            DeleteRowsOfTypeInternal(ref allIntColumns, removeAt, numberOfRowsToDelete);
 0295            DeleteRowsOfTypeInternal(ref allUintColumns, removeAt, numberOfRowsToDelete);
 0296            DeleteRowsOfTypeInternal(ref allLongColumns, removeAt, numberOfRowsToDelete);
 0297            DeleteRowsOfTypeInternal(ref allUlongColumns, removeAt, numberOfRowsToDelete);
 0298            DeleteRowsOfTypeInternal(ref allFloatColumns, removeAt, numberOfRowsToDelete);
 0299            DeleteRowsOfTypeInternal(ref allDoubleColumns, removeAt, numberOfRowsToDelete);
 0300            DeleteRowsOfTypeInternal(ref allVector2Columns, removeAt, numberOfRowsToDelete);
 0301            DeleteRowsOfTypeInternal(ref allVector3Columns, removeAt, numberOfRowsToDelete);
 0302            DeleteRowsOfTypeInternal(ref allVector4Columns, removeAt, numberOfRowsToDelete);
 0303            DeleteRowsOfTypeInternal(ref allVector2IntColumns, removeAt, numberOfRowsToDelete);
 0304            DeleteRowsOfTypeInternal(ref allVector3IntColumns, removeAt, numberOfRowsToDelete);
 0305            DeleteRowsOfTypeInternal(ref allQuaternionColumns, removeAt, numberOfRowsToDelete);
 0306            DeleteRowsOfTypeInternal(ref allRectColumns, removeAt, numberOfRowsToDelete);
 0307            DeleteRowsOfTypeInternal(ref allRectIntColumns, removeAt, numberOfRowsToDelete);
 0308            DeleteRowsOfTypeInternal(ref allColorColumns, removeAt, numberOfRowsToDelete);
 0309            DeleteRowsOfTypeInternal(ref allLayerMaskColumns, removeAt, numberOfRowsToDelete);
 0310            DeleteRowsOfTypeInternal(ref allBoundsColumns, removeAt, numberOfRowsToDelete);
 0311            DeleteRowsOfTypeInternal(ref allBoundsIntColumns, removeAt, numberOfRowsToDelete);
 0312            DeleteRowsOfTypeInternal(ref allHash128Columns, removeAt, numberOfRowsToDelete);
 0313            DeleteRowsOfTypeInternal(ref allGradientColumns, removeAt, numberOfRowsToDelete);
 0314            DeleteRowsOfTypeInternal(ref allAnimationCurveColumns, removeAt, numberOfRowsToDelete);
 0315            DeleteRowsOfTypeInternal(ref allObjectRefColumns, removeAt, numberOfRowsToDelete);
 316
 0317            rowCount -= numberOfRowsToDelete;
 0318            dataVersion++;
 0319        }
 320
 321
 322        // TODO: Need to make sure that insertAt is the stableID, also this should return the stableID of the newly crea
 323        public int AddColumn(Serializable.SerializableTypes columnType, string columnName, int insertAt = -1)
 0324        {
 0325            switch (columnType)
 326            {
 327                case Serializable.SerializableTypes.String:
 0328                    return AddColumnInternal(columnName, ref allStringColumns, Serializable.SerializableTypes.String, in
 329                case Serializable.SerializableTypes.Char:
 0330                    return AddColumnInternal(columnName, ref allCharColumns, Serializable.SerializableTypes.Char, insert
 331                case Serializable.SerializableTypes.Bool:
 0332                    return AddColumnInternal(columnName, ref allBoolColumns, Serializable.SerializableTypes.Bool, insert
 333                case Serializable.SerializableTypes.SByte:
 0334                    return AddColumnInternal(columnName, ref allSbyteColumns, Serializable.SerializableTypes.SByte, inse
 335                case Serializable.SerializableTypes.Byte:
 0336                    return AddColumnInternal(columnName, ref allByteColumns, Serializable.SerializableTypes.Byte, insert
 337                case Serializable.SerializableTypes.Short:
 0338                    return AddColumnInternal(columnName, ref allShortColumns, Serializable.SerializableTypes.Short, inse
 339                case Serializable.SerializableTypes.UShort:
 0340                    return AddColumnInternal(columnName, ref allUshortColumns, Serializable.SerializableTypes.UShort, in
 341                case Serializable.SerializableTypes.Int:
 0342                    return AddColumnInternal(columnName, ref allIntColumns, Serializable.SerializableTypes.Int, insertAt
 343                case Serializable.SerializableTypes.UInt:
 0344                    return AddColumnInternal(columnName, ref allUintColumns, Serializable.SerializableTypes.UInt, insert
 345                case Serializable.SerializableTypes.Long:
 0346                    return AddColumnInternal(columnName, ref allLongColumns, Serializable.SerializableTypes.Long, insert
 347                case Serializable.SerializableTypes.ULong:
 0348                    return AddColumnInternal(columnName, ref allUlongColumns, Serializable.SerializableTypes.ULong, inse
 349                case Serializable.SerializableTypes.Float:
 0350                    return AddColumnInternal(columnName, ref allFloatColumns, Serializable.SerializableTypes.Float, inse
 351                case Serializable.SerializableTypes.Double:
 0352                    return AddColumnInternal(columnName, ref allDoubleColumns, Serializable.SerializableTypes.Double, in
 353                case Serializable.SerializableTypes.Vector2:
 0354                    return AddColumnInternal(columnName, ref allVector2Columns, Serializable.SerializableTypes.Vector2, 
 355                case Serializable.SerializableTypes.Vector3:
 0356                    return AddColumnInternal(columnName, ref allVector3Columns, Serializable.SerializableTypes.Vector3, 
 357                case Serializable.SerializableTypes.Vector4:
 0358                    return AddColumnInternal(columnName, ref allVector4Columns, Serializable.SerializableTypes.Vector4, 
 359                case Serializable.SerializableTypes.Vector2Int:
 0360                    return AddColumnInternal(columnName, ref allVector2IntColumns, Serializable.SerializableTypes.Vector
 361                case Serializable.SerializableTypes.Vector3Int:
 0362                    return AddColumnInternal(columnName, ref allVector3IntColumns, Serializable.SerializableTypes.Vector
 363                case Serializable.SerializableTypes.Quaternion:
 0364                    return AddColumnInternal(columnName, ref allQuaternionColumns, Serializable.SerializableTypes.Quater
 365                case Serializable.SerializableTypes.Rect:
 0366                    return AddColumnInternal(columnName, ref allRectColumns, Serializable.SerializableTypes.Rect, insert
 367                case Serializable.SerializableTypes.RectInt:
 0368                    return AddColumnInternal(columnName, ref allRectIntColumns, Serializable.SerializableTypes.RectInt, 
 369                case Serializable.SerializableTypes.Color:
 0370                    return AddColumnInternal(columnName, ref allColorColumns, Serializable.SerializableTypes.Color, inse
 371                case Serializable.SerializableTypes.LayerMask:
 0372                    return AddColumnInternal(columnName, ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMa
 373                case Serializable.SerializableTypes.Bounds:
 0374                    return AddColumnInternal(columnName, ref allBoundsColumns, Serializable.SerializableTypes.Bounds, in
 375                case Serializable.SerializableTypes.BoundsInt:
 0376                    return AddColumnInternal(columnName, ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsI
 377                case Serializable.SerializableTypes.Hash128:
 0378                    return AddColumnInternal(columnName, ref allHash128Columns, Serializable.SerializableTypes.Hash128, 
 379                case Serializable.SerializableTypes.Gradient:
 0380                    return AddColumnInternal(columnName, ref allGradientColumns, Serializable.SerializableTypes.Gradient
 381                case Serializable.SerializableTypes.AnimationCurve:
 0382                    return AddColumnInternal(columnName, ref allAnimationCurveColumns, Serializable.SerializableTypes.An
 383                case Serializable.SerializableTypes.Object:
 0384                    return AddColumnInternal(columnName, ref allObjectRefColumns, Serializable.SerializableTypes.Object,
 385            }
 0386            return -1;
 0387        }
 388
 389        // TODO: need to make sure this is the stable ID?
 390        public void RemoveColumn(Serializable.SerializableTypes columnType, int removeAt = -1)
 0391        {
 0392            switch (columnType)
 393            {
 394                case Serializable.SerializableTypes.String:
 0395                    RemoveColumnInternal(ref allStringColumns, Serializable.SerializableTypes.String, removeAt);
 0396                    break;
 397                case Serializable.SerializableTypes.Char:
 0398                    RemoveColumnInternal(ref allCharColumns, Serializable.SerializableTypes.Char, removeAt);
 0399                    break;
 400                case Serializable.SerializableTypes.Bool:
 0401                    RemoveColumnInternal(ref allBoolColumns, Serializable.SerializableTypes.Bool, removeAt);
 0402                    break;
 403                case Serializable.SerializableTypes.SByte:
 0404                    RemoveColumnInternal(ref allSbyteColumns, Serializable.SerializableTypes.SByte, removeAt);
 0405                    break;
 406                case Serializable.SerializableTypes.Byte:
 0407                    RemoveColumnInternal(ref allByteColumns, Serializable.SerializableTypes.Byte, removeAt);
 0408                    break;
 409                case Serializable.SerializableTypes.Short:
 0410                    RemoveColumnInternal(ref allShortColumns, Serializable.SerializableTypes.Short, removeAt);
 0411                    break;
 412                case Serializable.SerializableTypes.UShort:
 0413                    RemoveColumnInternal(ref allUshortColumns, Serializable.SerializableTypes.UShort, removeAt);
 0414                    break;
 415                case Serializable.SerializableTypes.Int:
 0416                    RemoveColumnInternal(ref allIntColumns, Serializable.SerializableTypes.Int, removeAt);
 0417                    break;
 418                case Serializable.SerializableTypes.UInt:
 0419                    RemoveColumnInternal(ref allUintColumns, Serializable.SerializableTypes.UInt, removeAt);
 0420                    break;
 421                case Serializable.SerializableTypes.Long:
 0422                    RemoveColumnInternal(ref allLongColumns, Serializable.SerializableTypes.Long, removeAt);
 0423                    break;
 424                case Serializable.SerializableTypes.ULong:
 0425                    RemoveColumnInternal(ref allUlongColumns, Serializable.SerializableTypes.ULong, removeAt);
 0426                    break;
 427                case Serializable.SerializableTypes.Float:
 0428                    RemoveColumnInternal(ref allFloatColumns, Serializable.SerializableTypes.Float, removeAt);
 0429                    break;
 430                case Serializable.SerializableTypes.Double:
 0431                    RemoveColumnInternal(ref allDoubleColumns, Serializable.SerializableTypes.Double, removeAt);
 0432                    break;
 433                case Serializable.SerializableTypes.Vector2:
 0434                    RemoveColumnInternal(ref allVector2Columns, Serializable.SerializableTypes.Vector2, removeAt);
 0435                    break;
 436                case Serializable.SerializableTypes.Vector3:
 0437                    RemoveColumnInternal(ref allVector3Columns, Serializable.SerializableTypes.Vector3, removeAt);
 0438                    break;
 439                case Serializable.SerializableTypes.Vector4:
 0440                    RemoveColumnInternal(ref allVector4Columns, Serializable.SerializableTypes.Vector4, removeAt);
 0441                    break;
 442                case Serializable.SerializableTypes.Vector2Int:
 0443                    RemoveColumnInternal(ref allVector2IntColumns, Serializable.SerializableTypes.Vector2Int, removeAt);
 0444                    break;
 445                case Serializable.SerializableTypes.Vector3Int:
 0446                    RemoveColumnInternal(ref allVector3IntColumns, Serializable.SerializableTypes.Vector3Int, removeAt);
 0447                    break;
 448                case Serializable.SerializableTypes.Quaternion:
 0449                    RemoveColumnInternal(ref allQuaternionColumns, Serializable.SerializableTypes.Quaternion, removeAt);
 0450                    break;
 451                case Serializable.SerializableTypes.Rect:
 0452                    RemoveColumnInternal(ref allRectColumns, Serializable.SerializableTypes.Rect, removeAt);
 0453                    break;
 454                case Serializable.SerializableTypes.RectInt:
 0455                    RemoveColumnInternal(ref allRectIntColumns, Serializable.SerializableTypes.RectInt, removeAt);
 0456                    break;
 457                case Serializable.SerializableTypes.Color:
 0458                    RemoveColumnInternal(ref allColorColumns, Serializable.SerializableTypes.Color, removeAt);
 0459                    break;
 460                case Serializable.SerializableTypes.LayerMask:
 0461                    RemoveColumnInternal(ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMask, removeAt);
 0462                    break;
 463                case Serializable.SerializableTypes.Bounds:
 0464                    RemoveColumnInternal(ref allBoundsColumns, Serializable.SerializableTypes.Bounds, removeAt);
 0465                    break;
 466                case Serializable.SerializableTypes.BoundsInt:
 0467                    RemoveColumnInternal(ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsInt, removeAt);
 0468                    break;
 469                case Serializable.SerializableTypes.Hash128:
 0470                    RemoveColumnInternal(ref allHash128Columns, Serializable.SerializableTypes.Hash128, removeAt);
 0471                    break;
 472                case Serializable.SerializableTypes.Gradient:
 0473                    RemoveColumnInternal(ref allGradientColumns, Serializable.SerializableTypes.Gradient, removeAt);
 0474                    break;
 475                case Serializable.SerializableTypes.AnimationCurve:
 0476                    RemoveColumnInternal(ref allAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve, re
 0477                    break;
 478                case Serializable.SerializableTypes.Object:
 0479                    RemoveColumnInternal(ref allObjectRefColumns, Serializable.SerializableTypes.Object, removeAt);
 0480                    break;
 481            }
 0482        }
 483
 484
 485
 486
 487        // Set
 488
 489        public ulong SetString(int row, int column, string value)
 0490        {
 0491            return SetCell(row, column, ref allStringColumns, value);
 0492        }
 493
 494        public ulong SetBool(int row, int column, bool value)
 0495        {
 0496            return SetCell(row, column, ref allBoolColumns, value);
 0497        }
 498
 499        public ulong SetChar(int row, int column, char value)
 0500        {
 0501            return SetCell(row, column, ref allCharColumns, value);
 0502        }
 503
 504        public ulong SetSByte(int row, int column, sbyte value)
 0505        {
 0506            return SetCell(row, column, ref allSbyteColumns, value);
 0507        }
 508
 509        public ulong SetByte(int row, int column, byte value)
 0510        {
 0511            return SetCell(row, column, ref allByteColumns, value);
 0512        }
 513
 514        public ulong SetShort(int row, int column, short value)
 0515        {
 0516            return SetCell(row, column, ref allShortColumns, value);
 0517        }
 518
 519        public ulong SetUShort(int row, int column, ushort value)
 0520        {
 0521            return SetCell(row, column, ref allUshortColumns, value);
 0522        }
 523
 524        public ulong SetInt(int row, int column, int value)
 0525        {
 0526            return SetCell(row, column, ref allIntColumns, value);
 0527        }
 528
 529        public ulong SetUInt(int row, int column, uint value)
 0530        {
 0531            return SetCell(row, column, ref allUintColumns, value);
 0532        }
 533
 534        public ulong SetLong(int row, int column, long value)
 0535        {
 0536            return SetCell(row, column, ref allLongColumns, value);
 0537        }
 538
 539        public ulong SetULong(int row, int column, ulong value)
 0540        {
 0541            return SetCell(row, column, ref allUlongColumns, value);
 0542        }
 543
 544        public ulong SetFloat(int row, int column, float value)
 0545        {
 0546            return SetCell(row, column, ref allFloatColumns, value);
 0547        }
 548
 549        public ulong SetDouble(int row, int column, double value)
 0550        {
 0551            return SetCell(row, column, ref allDoubleColumns, value);
 0552        }
 553
 554        public ulong SetVector2(int row, int column, Vector2 value)
 0555        {
 0556            return SetCell(row, column, ref allVector2Columns, value);
 0557        }
 558
 559        public ulong SetVector3(int row, int column, Vector3 value)
 0560        {
 0561            return SetCell(row, column, ref allVector3Columns, value);
 0562        }
 563
 564        public ulong SetVector4(int row, int column, Vector4 value)
 0565        {
 0566            return SetCell(row, column, ref allVector4Columns, value);
 0567        }
 568
 569        public ulong SetVector2Int(int row, int column, Vector2Int value)
 0570        {
 0571            return SetCell(row, column, ref allVector2IntColumns, value);
 0572        }
 573
 574        public ulong SetVector3Int(int row, int column, Vector3Int value)
 0575        {
 0576            return SetCell(row, column, ref allVector3IntColumns, value);
 0577        }
 578
 579        public ulong SetQuaternion(int row, int column, Quaternion value)
 0580        {
 0581            return SetCell(row, column, ref allQuaternionColumns, value);
 0582        }
 583
 584        public ulong SetRect(int row, int column, Rect value)
 0585        {
 0586            return SetCell(row, column, ref allRectColumns, value);
 0587        }
 588
 589        public ulong SetRectInt(int row, int column, RectInt value)
 0590        {
 0591            return SetCell(row, column, ref allRectIntColumns, value);
 0592        }
 593
 594        public ulong SetColor(int row, int column, Color value)
 0595        {
 0596            return SetCell(row, column, ref allColorColumns, value);
 0597        }
 598
 599        public ulong SetLayerMask(int row, int column, LayerMask value)
 0600        {
 0601            return SetCell(row, column, ref allLayerMaskColumns, value);
 0602        }
 603
 604        public ulong SetBounds(int row, int column, Bounds value)
 0605        {
 0606            return SetCell(row, column, ref allBoundsColumns, value);
 0607        }
 608
 609        public ulong SetBoundsInt(int row, int column, BoundsInt value)
 0610        {
 0611            return SetCell(row, column, ref allBoundsIntColumns, value);
 0612        }
 613
 614        public ulong SetHash128(int row, int column, Hash128 value)
 0615        {
 0616            return SetCell(row, column, ref allHash128Columns, value);
 0617        }
 618
 619        public ulong SetGradient(int row, int column, Gradient value)
 0620        {
 0621            return SetCell(row, column, ref allGradientColumns, value);
 0622        }
 623
 624        public ulong SetAnimationCurve(int row, int column, AnimationCurve value)
 0625        {
 0626            return SetCell(row, column, ref allAnimationCurveColumns, value);
 0627        }
 628
 629        public ulong SetObject(int row, int column, UnityEngine.Object value)
 0630        {
 0631            return SetCell(row, column, ref allObjectRefColumns, value);
 0632        }
 633
 634        // Get
 635        public string GetString(int row, int column)
 0636        {
 0637            return GetCell(row, column, ref allStringColumns);
 0638        }
 639
 640        public bool GetBool(int row, int column)
 0641        {
 0642            return GetCell(row, column, ref allBoolColumns);
 0643        }
 644
 645        public char GetChar(int row, int column)
 0646        {
 0647            return GetCell(row, column, ref allCharColumns);
 0648        }
 649
 650        public sbyte GetSByte(int row, int column)
 0651        {
 0652            return GetCell(row, column, ref allSbyteColumns);
 0653        }
 654
 655        public byte GetByte(int row, int column)
 0656        {
 0657            return GetCell(row, column, ref allByteColumns);
 0658        }
 659
 660        public short GetShort(int row, int column)
 0661        {
 0662            return GetCell(row, column, ref allShortColumns);
 0663        }
 664
 665        public ushort GetUShort(int row, int column)
 0666        {
 0667            return GetCell(row, column, ref allUshortColumns);
 0668        }
 669
 670        public int GetInt(int row, int column)
 0671        {
 0672            return GetCell(row, column, ref allIntColumns);
 0673        }
 674
 675        public uint GetUInt(int row, int column)
 0676        {
 0677            return GetCell(row, column, ref allUintColumns);
 0678        }
 679
 680        public long GetLong(int row, int column)
 0681        {
 0682            return GetCell(row, column, ref allLongColumns);
 0683        }
 684
 685        public ulong GetULong(int row, int column)
 0686        {
 0687            return GetCell(row, column, ref allUlongColumns);
 0688        }
 689
 690        public float GetFloat(int row, int column)
 0691        {
 0692            return GetCell(row, column, ref allFloatColumns);
 0693        }
 694
 695        public double GetDouble(int row, int column)
 0696        {
 0697            return GetCell(row, column, ref allDoubleColumns);
 0698        }
 699
 700        public Vector2 GetVector2(int row, int column)
 0701        {
 0702            return GetCell(row, column, ref allVector2Columns);
 0703        }
 704
 705        public Vector3 GetVector3(int row, int column)
 0706        {
 0707            return GetCell(row, column, ref allVector3Columns);
 0708        }
 709
 710        public Vector4 GetVector4(int row, int column)
 0711        {
 0712            return GetCell(row, column, ref allVector4Columns);
 0713        }
 714
 715        public Vector2Int GetVector2Int(int row, int column)
 0716        {
 0717            return GetCell(row, column, ref allVector2IntColumns);
 0718        }
 719
 720        public Vector3Int GetVector3Int(int row, int column)
 0721        {
 0722            return GetCell(row, column, ref allVector3IntColumns);
 0723        }
 724
 725        public Quaternion GetQuaternion(int row, int column)
 0726        {
 0727            return GetCell(row, column, ref allQuaternionColumns);
 0728        }
 729
 730        public Rect GetRect(int row, int column)
 0731        {
 0732            return GetCell(row, column, ref allRectColumns);
 0733        }
 734
 735        public RectInt GetRectInt(int row, int column)
 0736        {
 0737            return GetCell(row, column, ref allRectIntColumns);
 0738        }
 739
 740        public Color GetColor(int row, int column)
 0741        {
 0742            return GetCell(row, column, ref allColorColumns);
 0743        }
 744
 745        public LayerMask GetLayerMask(int row, int column)
 0746        {
 0747            return GetCell(row, column, ref allLayerMaskColumns);
 0748        }
 749
 750        public Bounds GetBounds(int row, int column)
 0751        {
 0752            return GetCell(row, column, ref allBoundsColumns);
 0753        }
 754
 755        public BoundsInt GetBoundsInt(int row, int column)
 0756        {
 0757            return GetCell(row, column, ref allBoundsIntColumns);
 0758        }
 759
 760        public Hash128 GetHash128(int row, int column)
 0761        {
 0762            return GetCell(row, column, ref allHash128Columns);
 0763        }
 764
 765        public Gradient GetGradient(int row, int column)
 0766        {
 0767            return GetCell(row, column, ref allGradientColumns);
 0768        }
 769
 770        public AnimationCurve GetAnimationCurve(int row, int column)
 0771        {
 0772            return GetCell(row, column, ref allAnimationCurveColumns);
 0773        }
 774
 775        public UnityEngine.Object GetObject(int row, int column)
 0776        {
 0777            return GetCell(row, column, ref allObjectRefColumns);
 0778        }
 779
 780        // Get ref
 781
 782        public ref string GetStringRef(int row, int columnID)
 0783        {
 0784            return ref GetCellRef(row, columnID, ref allStringColumns);
 0785        }
 786
 787        public ref bool GetBoolRef(int row, int columnID)
 0788        {
 0789            return ref GetCellRef(row, columnID, ref allBoolColumns);
 0790        }
 791
 792        public ref char GetCharRef(int row, int columnID)
 0793        {
 0794            return ref GetCellRef(row, columnID, ref allCharColumns);
 0795        }
 796
 797        public ref sbyte GetSbyteRef(int row, int columnID)
 0798        {
 0799            return ref GetCellRef(row, columnID, ref allSbyteColumns);
 0800        }
 801
 802        public ref byte GetByteRef(int row, int columnID)
 0803        {
 0804            return ref GetCellRef(row, columnID, ref allByteColumns);
 0805        }
 806
 807        public ref short GetShortRef(int row, int columnID)
 0808        {
 0809            return ref GetCellRef(row, columnID, ref allShortColumns);
 0810        }
 811
 812        public ref ushort GetUshortRef(int row, int columnID)
 0813        {
 0814            return ref GetCellRef(row, columnID, ref allUshortColumns);
 0815        }
 816
 817        public ref int GetIntRef(int row, int columnID)
 0818        {
 0819            return ref GetCellRef(row, columnID, ref allIntColumns);
 0820        }
 821
 822        public ref uint GetUintRef(int row, int columnID)
 0823        {
 0824            return ref GetCellRef(row, columnID, ref allUintColumns);
 0825        }
 826
 827        public ref long GetLongRef(int row, int columnID)
 0828        {
 0829            return ref GetCellRef(row, columnID, ref allLongColumns);
 0830        }
 831
 832        public ref ulong GetUlongRef(int row, int columnID)
 0833        {
 0834            return ref GetCellRef(row, columnID, ref allUlongColumns);
 0835        }
 836
 837        public ref float GetFloatRef(int row, int columnID)
 0838        {
 0839            return ref GetCellRef(row, columnID, ref allFloatColumns);
 0840        }
 841
 842        public ref double GetDoubleRef(int row, int columnID)
 0843        {
 0844            return ref GetCellRef(row, columnID, ref allDoubleColumns);
 0845        }
 846
 847        public ref Vector2 GetVector2Ref(int row, int columnID)
 0848        {
 0849            return ref GetCellRef(row, columnID, ref allVector2Columns);
 0850        }
 851
 852        public ref Vector3 GetVector3Ref(int row, int columnID)
 0853        {
 0854            return ref GetCellRef(row, columnID, ref allVector3Columns);
 0855        }
 856
 857        public ref Vector4 GetVector4Ref(int row, int columnID)
 0858        {
 0859            return ref GetCellRef(row, columnID, ref allVector4Columns);
 0860        }
 861
 862        public ref Vector2Int GetVector2IntRef(int row, int columnID)
 0863        {
 0864            return ref GetCellRef(row, columnID, ref allVector2IntColumns);
 0865        }
 866
 867        public ref Vector3Int GetVector3IntRef(int row, int columnID)
 0868        {
 0869            return ref GetCellRef(row, columnID, ref allVector3IntColumns);
 0870        }
 871
 872        public ref Quaternion GetQuaternionRef(int row, int columnID)
 0873        {
 0874            return ref GetCellRef(row, columnID, ref allQuaternionColumns);
 0875        }
 876
 877        public ref Rect GetRectRef(int row, int columnID)
 0878        {
 0879            return ref GetCellRef(row, columnID, ref allRectColumns);
 0880        }
 881
 882        public ref RectInt GetRectIntRef(int row, int columnID)
 0883        {
 0884            return ref GetCellRef(row, columnID, ref allRectIntColumns);
 0885        }
 886
 887        public ref Color GetColorRef(int row, int columnID)
 0888        {
 0889            return ref GetCellRef(row, columnID, ref allColorColumns);
 0890        }
 891
 892        public ref LayerMask GetLayerMaskRef(int row, int columnID)
 0893        {
 0894            return ref GetCellRef(row, columnID, ref allLayerMaskColumns);
 0895        }
 896
 897        public ref Bounds GetBoundsRef(int row, int columnID)
 0898        {
 0899            return ref GetCellRef(row, columnID, ref allBoundsColumns);
 0900        }
 901
 902        public ref BoundsInt GetBoundsIntRef(int row, int columnID)
 0903        {
 0904            return ref GetCellRef(row, columnID, ref allBoundsIntColumns);
 0905        }
 906
 907        public ref Hash128 GetHash128Ref(int row, int columnID)
 0908        {
 0909            return ref GetCellRef(row, columnID, ref allHash128Columns);
 0910        }
 911
 912        public ref Gradient GetGradientRef(int row, int columnID)
 0913        {
 0914            return ref GetCellRef(row, columnID, ref allGradientColumns);
 0915        }
 916
 917        public ref AnimationCurve GetAnimationCurveRef(int row, int columnID)
 0918        {
 0919            return ref GetCellRef(row, columnID, ref allAnimationCurveColumns);
 0920        }
 921
 922        public ref UnityEngine.Object GetObjectRef(int row, int columnID)
 0923        {
 0924            return ref GetCellRef(row, columnID, ref allObjectRefColumns);
 0925        }
 926
 927        // Get Column
 928
 929        public string[] GetStringColumn(int columnID)
 0930        {
 0931            return GetColumn(columnID, ref allStringColumns);
 0932        }
 933
 934        public bool[] GetBoolColumn(int columnID)
 0935        {
 0936            return GetColumn(columnID, ref allBoolColumns);
 0937        }
 938
 939        public char[] GetCharColumn(int columnID)
 0940        {
 0941            return GetColumn(columnID, ref allCharColumns);
 0942        }
 943
 944        public sbyte[] GetSbyteColumn(int columnID)
 0945        {
 0946            return GetColumn(columnID, ref allSbyteColumns);
 0947        }
 948
 949        public byte[] GetByteColumn(int columnID)
 0950        {
 0951            return GetColumn(columnID, ref allByteColumns);
 0952        }
 953
 954        public short[] GetShortColumn(int columnID)
 0955        {
 0956            return GetColumn(columnID, ref allShortColumns);
 0957        }
 958
 959        public ushort[] GetUshortColumn(int columnID)
 0960        {
 0961            return GetColumn(columnID, ref allUshortColumns);
 0962        }
 963
 964        public int[] GetIntColumn(int columnID)
 0965        {
 0966            return GetColumn(columnID, ref allIntColumns);
 0967        }
 968
 969        public uint[] GetUintColumn(int columnID)
 0970        {
 0971            return GetColumn(columnID, ref allUintColumns);
 0972        }
 973
 974        public long[] GetLongColumn(int columnID)
 0975        {
 0976            return GetColumn(columnID, ref allLongColumns);
 0977        }
 978
 979        public ulong[] GetUlongColumn(int columnID)
 0980        {
 0981            return GetColumn(columnID, ref allUlongColumns);
 0982        }
 983
 984        public float[] GetFloatColumn(int columnID)
 0985        {
 0986            return GetColumn(columnID, ref allFloatColumns);
 0987        }
 988
 989        public double[] GetDoubleColumn(int columnID)
 0990        {
 0991            return GetColumn(columnID, ref allDoubleColumns);
 0992        }
 993
 994        public Vector2[] GetVector2Column(int columnID)
 0995        {
 0996            return GetColumn(columnID, ref allVector2Columns);
 0997        }
 998
 999        public Vector3[] GetVector3Column(int columnID)
 01000        {
 01001            return GetColumn(columnID, ref allVector3Columns);
 01002        }
 1003
 1004        public Vector4[] GetVector4Column(int columnID)
 01005        {
 01006            return GetColumn(columnID, ref allVector4Columns);
 01007        }
 1008
 1009        public Vector2Int[] GetVector2IntColumn(int columnID)
 01010        {
 01011            return GetColumn(columnID, ref allVector2IntColumns);
 01012        }
 1013
 1014        public Vector3Int[] GetVector3IntColumn(int columnID)
 01015        {
 01016            return GetColumn(columnID, ref allVector3IntColumns);
 01017        }
 1018
 1019        public Quaternion[] GetQuaternionColumn(int columnID)
 01020        {
 01021            return GetColumn(columnID, ref allQuaternionColumns);
 01022        }
 1023
 1024        public Rect[] GetRectColumn(int columnID)
 01025        {
 01026            return GetColumn(columnID, ref allRectColumns);
 01027        }
 1028
 1029        public RectInt[] GetRectIntColumn(int columnID)
 01030        {
 01031            return GetColumn(columnID, ref allRectIntColumns);
 01032        }
 1033
 1034        public Color[] GetColorColumn(int columnID)
 01035        {
 01036            return GetColumn(columnID, ref allColorColumns);
 01037        }
 1038
 1039        public LayerMask[] GetLayerMaskColumn(int columnID)
 01040        {
 01041            return GetColumn(columnID, ref allLayerMaskColumns);
 01042        }
 1043
 1044        public Bounds[] GetBoundsColumn(int columnID)
 01045        {
 01046            return GetColumn(columnID, ref allBoundsColumns);
 01047        }
 1048
 1049        public BoundsInt[] GetBoundsIntColumn(int columnID)
 01050        {
 01051            return GetColumn(columnID, ref allBoundsIntColumns);
 01052        }
 1053
 1054        public Hash128[] GetHash128Column(int columnID)
 01055        {
 01056            return GetColumn(columnID, ref allHash128Columns);
 01057        }
 1058
 1059        public Gradient[] GetGradientColumn(int columnID)
 01060        {
 01061            return GetColumn(columnID, ref allGradientColumns);
 01062        }
 1063
 1064        public AnimationCurve[] GetAnimationCurveColumn(int columnID)
 01065        {
 01066            return GetColumn(columnID, ref allAnimationCurveColumns);
 01067        }
 1068
 1069        public UnityEngine.Object[] GetObjectColumn(int columnID)
 01070        {
 01071            return GetColumn(columnID, ref allObjectRefColumns);
 01072        }
 1073
 1074        // Internal
 1075
 1076        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType, Serializable.Seriali
 01077        {
 01078            int columnCount = allColumnsOfType?.Length ?? 0;
 01079            Array.Resize(ref allColumnsOfType, columnCount + 1);
 01080            allColumnsOfType[columnCount].TArray = new T[rowCount];
 1081
 01082            string[] columnNamesForType = allColumnNames[(int)typeIndex].TArray;
 01083            int columnNamesCount = columnNamesForType?.Length ?? 0;
 01084            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 01085            columnNamesForType[columnNamesCount] = columnName;
 01086            allColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1087
 01088            int columnIndex = columnEntriesFreeListHead;
 01089            int columnIDToDenseIndexMapLength = columnIDToDenseIndexMap?.Length ?? 0;
 01090            if (columnIndex >= columnIDToDenseIndexMapLength)
 01091            {
 01092                int newSize = columnIndex * 2;
 01093                newSize = newSize == 0 ? 1 : newSize;
 01094                Array.Resize(ref columnIDToDenseIndexMap, newSize);
 01095                for (int i = 0; i < columnIndex; i++)
 01096                {
 01097                    ref ColumnEntry entry = ref columnIDToDenseIndexMap[columnIndex + i];
 01098                    entry.columnDenseIndex = columnIndex + i + 1;
 01099                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 01100                }
 01101            }
 1102
 01103            ref int[] denseIndexToIDMap = ref columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01104            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 01105            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 01106            denseIndexToIDMap[denseIndexToIDMapLength] = columnIndex;
 1107
 01108            ref ColumnEntry newEntry = ref columnIDToDenseIndexMap[columnIndex];
 01109            newEntry.columnDenseIndex = denseIndexToIDMapLength;
 01110            newEntry.ColumnType = typeIndex;
 1111
 01112            insertAt = insertAt < 0 ? combinedColumnCount : insertAt;
 01113            ref int[] columnOrdersOfType = ref allColumnOrders[(int)typeIndex].TArray;
 01114            int columnOrdersOfTypeLength = columnOrdersOfType?.Length ?? 0;
 01115            Array.Resize(ref columnOrdersOfType, columnOrdersOfTypeLength + 1);
 01116            columnOrdersOfType[columnOrdersOfTypeLength] = insertAt;
 1117
 01118            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 01119            {
 01120                int[] columnOrdersOfTypeCurrent = allColumnOrders[i].TArray;
 01121                int columnOrdersLength = columnOrdersOfTypeCurrent?.Length ?? 0;
 01122                for (int j = 0; j < columnOrdersLength; j++)
 01123                {
 01124                    int columnOrderCurrent = columnOrdersOfTypeCurrent[j];
 1125
 01126                    if (columnOrderCurrent > insertAt)
 01127                    {
 01128                        columnOrdersOfType[j] = columnOrderCurrent + 1;
 01129                    }
 01130                }
 01131            }
 1132
 01133            ++combinedColumnCount;
 01134            dataVersion++;
 1135
 01136            return columnIndex;
 01137        }
 1138
 1139        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, Serializable.SerializableTypes type
 01140        {
 01141            int columnLocation = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 1142
 01143            int lastIndex = allColumnsOfType.Length - 1;
 01144            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 1145           // T[][] newColumnArray = new T[lastIndex][];
 01146            ArrayHolder<T>[] newColumnArray = new ArrayHolder<T>[lastIndex];
 01147            Array.Copy(allColumnsOfType, 0, newColumnArray, 0, lastIndex);
 01148            allColumnsOfType = newColumnArray;
 1149
 01150            string[] columnNamesOfType = allColumnNames[(int)typeIndex].TArray;
 01151            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 01152            string[] newColumnNamesOfType = new string[lastIndex];
 01153            Array.Copy(columnNamesOfType, 0, newColumnNamesOfType, 0, lastIndex);
 01154            allColumnNames[(int)typeIndex].TArray = newColumnNamesOfType;
 1155
 01156            int[] columnOrdersOfType = allColumnOrders[(int)typeIndex].TArray;
 01157            int columnOrder = columnOrdersOfType[columnLocation];
 01158            columnOrdersOfType[columnLocation] = columnOrdersOfType[lastIndex];
 01159            int[] newColumnOrdersOfType = new int[lastIndex];
 01160            Array.Copy(columnOrdersOfType, 0, newColumnOrdersOfType, 0, lastIndex);
 01161            allColumnOrders[(int)typeIndex].TArray = newColumnOrdersOfType;
 1162
 01163            int[] denseIndicesOfType = columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01164            int sparseIndexAt = denseIndicesOfType[columnLocation];
 01165            int sparseIndexToSwap = columnOrdersOfType[lastIndex];
 01166            ref ColumnEntry sparseIndexToFree = ref columnIDToDenseIndexMap[sparseIndexAt];
 01167            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 01168            sparseIndexToFree.columnDenseIndex = columnEntriesFreeListHead;
 01169            columnEntriesFreeListHead = sparseIndexAt;
 01170            columnIDToDenseIndexMap[sparseIndexToSwap].columnDenseIndex = columnLocation;
 01171            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 01172            int[] newDenseIndicesOfType = new int[lastIndex];
 01173            Array.Copy(denseIndicesOfType, 0, newDenseIndicesOfType, 0, lastIndex);
 01174            columnDenseIndexToIDMap[(int)typeIndex].TArray = newDenseIndicesOfType;
 1175
 01176            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 01177            {
 01178                int[] columnOrdersOfTypeCurrent = allColumnOrders[i].TArray;
 1179
 01180                int columnOrdersLength = columnOrdersOfTypeCurrent.Length;
 01181                for (int j = 0; j < columnOrdersLength; j++)
 01182                {
 01183                    int columnOrderCurrent = columnOrdersOfTypeCurrent[j];
 1184
 01185                    if (columnOrderCurrent > columnOrder)
 01186                    {
 01187                        columnOrdersOfType[j] = columnOrderCurrent - 1;
 01188                    }
 01189                }
 01190            }
 1191
 01192            --combinedColumnCount;
 01193            dataVersion++;
 01194        }
 1195
 1196        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt, int numberOfNewRo
 01197        {
 01198            int columnCount = allColumnsOfType?.Length ?? 0;
 01199            for (int i = 0; i < columnCount; i++)
 01200            {
 01201                ref T[] column = ref allColumnsOfType[i].TArray;
 01202                int newRowCount = rowCount + numberOfNewRows;
 01203                Array.Resize(ref column, newRowCount);
 01204                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01205                {
 01206                    column[j] = column[j - numberOfNewRows];
 01207                }
 1208
 01209                for (int j = 0; j < numberOfNewRows; j++)
 01210                {
 01211                    column[insertAt + i] = default;
 01212                }
 01213            }
 01214        }
 1215
 1216        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt, int numberOfRowsT
 01217        {
 01218            int columnCount = allColumnsOfType?.Length ?? 0;
 1219
 01220            for (int i = 0; i < columnCount; i++)
 01221            {
 01222                ref T[] column = ref allColumnsOfType[i].TArray;
 01223                int newRowCount = rowCount - numberOfRowsToDelete;
 1224
 01225                for (int j = removeAt; j < rowCount - numberOfRowsToDelete; j++)
 01226                {
 01227                    column[j] = column[j + numberOfRowsToDelete];
 01228                }
 1229
 01230                Array.Resize(ref column, newRowCount);
 01231            }
 01232        }
 1233
 1234        internal ref T GetCellRef<T>(int row, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01235        {
 01236            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01237            return ref allColumnsOfType[column][row];
 01238        }
 1239
 1240        internal T GetCell<T>(int row, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01241        {
 01242            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01243            return allColumnsOfType[column][row];
 01244        }
 1245
 1246        internal ulong SetCell<T>(int row, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 01247        {
 01248            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01249            allColumnsOfType[column][row] = value;
 01250            dataVersion++;
 01251            return dataVersion;
 01252        }
 1253
 1254        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01255        {
 01256            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01257            return allColumnsOfType[column].TArray;
 01258        }
 1259    }
 1260}
Generated by: ReportGenerator 5.0.4.0
2023-05-19 - 11:59:40 AM
GitHub | www.palmmedia.de

Coverage by test methods





































































































































































































































































































































































































































































































































































































































































































Methods/Properties

StableTable()
GetDataVersion()
GetColumnCount()
GetRowCount()
GetOrderedColumns()
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
RemoveRow(System.Int32)
RemoveRows(System.Int32, System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )